home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1998 June / SGI Freeware 1998 June.iso / dist / fw_ATxgopher.idb / usr / freeware / src / xgopher.1.3 / sc_image.c.z / sc_image.c
C/C++ Source or Header  |  1998-01-21  |  5KB  |  204 lines
  1. /* sc_image.c
  2.    gopher item subclass procedures for image */
  3.  
  4.      /*---------------------------------------------------------------*/
  5.      /* Xgopher        version 1.3     08 April 1993                  */
  6.      /*                version 1.2     20 November 1992               */
  7.      /*                version 1.1     20 April 1992                  */
  8.      /*                version 1.0     04 March 1992                  */
  9.      /* X window system client for the University of Minnesota        */
  10.      /*                                Internet Gopher System.        */
  11.      /* Allan Tuchman, University of Illinois at Urbana-Champaign     */
  12.      /*                Computing and Communications Services Office   */
  13.      /* Copyright 1992, 1993 by                                       */
  14.      /*           the Board of Trustees of the University of Illinois */
  15.      /* Permission is granted to freely copy and redistribute this    */
  16.      /* software with the copyright notice intact.                    */
  17.      /*---------------------------------------------------------------*/
  18.  
  19. #include "conf.h"
  20. #include "osdep.h"
  21. #include "globals.h"
  22. #include "gopher.h"
  23. #include "appres.h"
  24. #include "util.h"
  25. #include "status.h"
  26. #include "subst.h"
  27. #include "jobs.h"
  28. #include "sc_image.h"
  29. #include "sc_imageP.h"
  30.  
  31. #include <sys/file.h>
  32. extern     errno;
  33.  
  34.  
  35.  
  36. /* getImage
  37.    get an image file and display it.  Since image display may take a
  38.    while, we just fork the process and let it occur asynchronously. */
  39.  
  40. BOOLEAN
  41. getImage(gi)
  42. gopherItemP    gi;
  43. {
  44.     char    errorString[MESSAGE_STRING_LEN];
  45.     char    tempName[PATH_NAME_LEN];
  46.     char    message[MESSAGE_STRING_LEN];
  47.     int    tempFD;
  48.     BOOLEAN    okSoFar;
  49.     char    *imageCmd;    
  50.     char    *path, *suffix=NULL;
  51.  
  52.     PID_TYPE    imagePID = (PID_TYPE) 0;
  53.  
  54.  
  55.     if ((int) strlen ( appResources->imageCommand ) <= 0 ) {
  56.         showError("Cannot execute the image command");
  57.         return FALSE;
  58.     }
  59.  
  60.     getTempFile(tempName);
  61.  
  62.     /* find the file name suffix which may indicate the image
  63.        file type -- if possible */
  64.  
  65.     path = vStringValue(&(gi->selector));
  66.     suffix = rindex(path, '.');
  67.     if (suffix != NULL) {
  68.  
  69.         /* find length of ".xxx".  If it's 4 or fewer characters
  70.            after the dot, assume that it's a meaningful suffix
  71.            and copy it to the end of the temp file name. */
  72.  
  73.         int    nch = strlen(suffix);
  74.  
  75.         if (nch <= 4) {
  76.             strcat (tempName, suffix);
  77.         }
  78.     }
  79.  
  80.     if ((tempFD = open(tempName, O_WRONLY | O_CREAT, TMP_FILE_MODE)) < 0) {
  81.         
  82.         perror("getImage");
  83.         (void) removeStatusPanel();
  84.  
  85.         sprintf(errorString,
  86.             "Cannot open the temporary file %s", tempName);
  87.         showError(errorString);
  88.         fprintf (stderr, "%s\n", errorString);
  89.         return FALSE;
  90.     }
  91.  
  92.     okSoFar = GI_copyFromNet(tempFD, gi, "Getting image file");
  93.  
  94.     close(tempFD);
  95.  
  96.     if (! okSoFar) {
  97.         unlink (tempName);
  98.         return FALSE;
  99.     }
  100.  
  101.     imageCmd = editCommand(gi, appResources->imageCommand,
  102.                 tempName, tempName);
  103.     showStatus("Preparing image for display", STAT_TEMP_MESSAGE,
  104.             (char *) NULL, 0);
  105.  
  106.     if ((imagePID = fork()) < 0) {
  107.         sprintf(message,
  108.             "Unable to prepare for an image display (error %d)\n",
  109.             errno);
  110.         showError(message);
  111.         unlink (tempName);
  112.         free(imageCmd);
  113.         return FALSE;
  114.  
  115.     } else if (imagePID == 0) {
  116.  
  117.         /* we should immediately do a 
  118.               close (ConnectionNumber(XtDisplay(widget)));
  119.            here.  */
  120.  
  121.            
  122.         system(imageCmd);
  123.         unlink (tempName);
  124.  
  125.         exit(0);
  126.     }
  127.  
  128.     /* parent just returns as child does the display */
  129.  
  130.     addJob(gi->type, imagePID);
  131.     free(imageCmd);
  132.  
  133.     return TRUE;
  134. }
  135.  
  136.  
  137. /* GIImage_init
  138.    initialize image class - host access list and prefix. */
  139.  
  140. void
  141. GIImage_init()
  142. {
  143.     GU_makePrefix(prefixImage,  appResources->prefixImage);
  144.     imageHostList = GU_createAccessList(appResources->imageServers);
  145.     GU_registerNewType(A_IMAGE, &imageSubclass);
  146.  
  147.     /* as a matter of security, in public mode, if there are no
  148.        restrictions, images should be banned.  It is easy to
  149.        overcome these restrictions by creating a list such as
  150.        ".edu .com .mil .gov .net" etc.  */
  151.  
  152.     if (appResources->publicMode  &&  imageHostList == NULL) {
  153.         appResources->allowImage = False;
  154.     }
  155.  
  156.     return;
  157. }
  158.  
  159.  
  160. /* GIImage_access
  161.    check the accessability of an image file selection */
  162.  
  163. BOOLEAN
  164. GIImage_access(gi)
  165. gopherItemP    gi;
  166. {
  167.     BOOLEAN    result;
  168.  
  169.     if (appResources->allowImage  &&
  170.         (imageHostList == NULL  ||
  171.                 GU_checkAccess(gi->host, imageHostList))) {
  172.         result = TRUE;
  173.     }else {
  174.         result = FALSE;
  175.     }
  176.  
  177.     return result;
  178. }
  179.  
  180.  
  181. /* GIImage_restart
  182.    kill all image command process if possible. */
  183.  
  184. void
  185. GIImage_restart()
  186. {
  187.     killAllItemType(A_IMAGE);
  188. }
  189.  
  190.  
  191. /* GIImage_process
  192.    process an image file selection */
  193.  
  194. BOOLEAN
  195. GIImage_process(gi)
  196. gopherItemP    gi;
  197. {
  198.     BOOLEAN    result;
  199.     
  200.     result = getImage(gi);
  201.  
  202.     return result;
  203. }
  204.